(function() {"use strict";var __module = CC_EDITOR ? module : {exports:{}};var __filename = 'preview-scripts/assets/module/game/dizhu/script/DizhuBegin.js';var __require = CC_EDITOR ? function (request) {return cc.require(request, require);} : function (request) {return cc.require(request, __filename);};function __define (exports, require, module) {"use strict";
cc._RF.push(module, 'cc414fafx1EfIEhdfVAesnW', 'DizhuBegin', __filename);
// module/game/dizhu/script/DizhuBegin.js

"use strict";

var beiMiCommon = require("BeiMiCommon");
cc.Class({
    extends: beiMiCommon,

    properties: {
        // foo: {
        //    default: null,      // The default value will be used only when the component attaching
        //                           to a node for the first time
        //    url: cc.Texture2D,  // optional, default is typeof default
        //    serializable: true, // optional, default is true
        //    visible: true,      // optional, default is true
        //    displayName: 'Foo', // optional
        //    readonly: false,    // optional, default is false
        // },
        // ...
        gamebtn: {
            default: null,
            type: cc.Node
        },
        continuegamebtn: {
            default: null,
            type: cc.Node
        },
        poker: {
            default: null,
            type: cc.Node
        },
        lastCardsPanel: { //底牌
            default: null,
            type: cc.Node
        },
        waitting: {
            default: null,
            type: cc.Prefab
        },
        ratio: { //底牌
            default: null,
            type: cc.Label
        },
        summary_win: {
            default: null,
            type: cc.Prefab
        },
        summary: {
            default: null,
            type: cc.Prefab
        },
        inviteplayer: {
            default: null,
            type: cc.Prefab
        },
        chat: {
            default: null,
            type: cc.Node
        }
    },

    // use this for initialization
    onLoad: function onLoad() {
        /**
         * 适配屏幕尺寸
         */
        this.resize();

        this.player = new Array(); //存放玩家数据
        this.pokercards = new Array();
        this.lastcards = new Array();
        this.lastCardsPanel.active = false;
        this.summarypage = null;
        this.inited = false;
        this.lasttip = null;
        this.isInviteDestroy = false;
        if (cc.beimi != null) {
            if (cc.beimi.gamestatus != null && cc.beimi.gamestatus == "playing") {
                //恢复数据
                this.recovery();
            } else if (cc.beimi.extparams != null && cc.beimi.extparams.gamemodel == "room") {
                /**
                 * 房卡模式，开始启动游戏，当前玩家进入等待游戏的状态，显示邀请好友游戏，并分配 6位数字的房间号码
                 */
                /**
                 * 处理完毕，清理掉全局变量
                 * @type {null}
                 */
                this.invite = cc.instantiate(this.inviteplayer);
            }
            this.initgame();
        }
    },
    begin: function begin() {
        if (cc.beimi.data != null && cc.beimi.data.enableai == true) {
            this.statictimer("正在匹配玩家", cc.beimi.data.waittime);
        } else {
            this.statictimer("正在匹配玩家，请稍候", cc.beimi.data.noaiwaitime);
        }
        this.startgame("false");
    },
    opendeal: function opendeal() {
        if (cc.beimi.data != null && cc.beimi.data.enableai == true) {
            this.statictimer("正在匹配玩家", cc.beimi.data.waittime);
        } else {
            this.statictimer("正在匹配玩家，请稍候", cc.beimi.data.noaiwaitime);
        }
        this.startgame("true");
    },
    recovery: function recovery() {
        this.statictimer("正在恢复数据，请稍候", cc.beimi.data.waittime);
    },
    initgame: function initgame() {
        var self = this;
        this.gamebtn.active = true;
        this.continuegamebtn.active = false;
        if (this.ready()) {
            var socket = this.socket();

            this.game = this.getCommon("DizhuDataBind");

            this.map("joinroom", this.joinroom_event); //加入房价
            this.map("players", this.players_event); //接受玩家列表
            this.map("catch", this.catch_event); //叫地主
            this.map("catchresult", this.catchresult_event); //最终抢到地主的玩家
            this.map("lasthands", this.lasthands_event); //翻底牌
            this.map("takecards", this.takecards_event); //出牌信息
            this.map("ratio", this.ratio_event); //有炸
            this.map("play", this.play_event); //接受玩家列表
            this.map("allcards", this.allcards_event); //我出的牌
            this.map("cardtips", this.cardtips_event); //提示
            this.map("roomready", this.roomready_event); //提示

            this.map("playeready", this.playeready_event); //玩家点击了开始游戏 ， 即准备就绪

            this.map("cardtips", this.cardtips_event); //提示

            this.map("recovery", this.recovery_event); //恢复牌局数据


            this.map("leaveRoom", this.playerLeave_event); //当有其他玩家离开，删除玩家数据

            this.map("roomMsg", this.roomMsg_event); //玩家聊天数据

            socket.on("command", function (result) {
                cc.beimi.gamestatus = "playing";
                if (self.inited == true) {
                    var data = self.parse(result);
                    self.route(data.command)(data, self);
                }
            });
            /**
             * 心跳检查，服务端发起的事件，服务端可以设置 PING的时长和 PING的 TimeOut
             */
            socket.on("ping", function () {});

            /**
             *   此处有个问题：游戏中，如果点击了返回，进入过其他游戏，这个 cc.beimi.extparams.playway
             *   就发生了改变，会导致当前游戏结束后，继续游戏的时候会出现问题
             * @type {{token: (*|null), playway, orgi, extparams: *}}
             */
            var param = {
                token: cc.beimi.authorization,
                playway: cc.beimi.extparams.playway,
                orgi: cc.beimi.user.orgi,
                extparams: cc.beimi.extparams,
                roomId: cc.beimi.extparams.roomId
            };
            socket.emit("joinroom", JSON.stringify(param));

            this.inited = true;
        }
    },
    /**
     * 新创建牌局，首个玩家加入，进入等待状态，等待其他玩家加入，服务端会推送 players数据
     * @param data
     * @param context
     */
    joinroom_event: function joinroom_event(data, context) {
        console.log("斗地主，加入房间");

        if (data.cardroom == true && context.inviteplayer != null && context.invite) {
            var script = context.invite.getComponent("BeiMiQR");
            script.init(data.roomid);
            context.invite.parent = context.root();
        }

        //显示 匹配中，并计时间，超过设定的倒计时时间即AI加入，根据当前的 玩家数量 匹配机器人
        //cc.beimi.user.id当前用户的ID
        if (data.player.id && data.player.id == cc.beimi.user.id) {
            //本人，开始计时
            //console.log("本人") ;
            //self.player[0] = data ;
            context.index = data.index; //当前玩家所在位置
        } else {
            //其他玩家加入，初始化
            var inroom = false;
            //检查当前玩家是否在房间内
            for (var i = 0; i < context.player.length; i++) {
                var player = context.player[i].getComponent("PlayerRender");
                if (player.userid == data.player.id) {
                    inroom = true;
                }
            }
            if (inroom == false) {
                context.newplayer(context.player.length, context, data.player, context.index + 1 == data.index);
            }
        }
    },
    /**
     * 房卡模式下，邀请的好友人到齐了
     * @param data
     * @param context
     */
    roomready_event: function roomready_event(data, context) {
        if (data.cardroom == true && context.invite != null) {
            context.invite.destroy();
            context.isInviteDestroy = true;
        }
    },
    /**
     *
     * @param data
     * @param context
     */
    playeready_event: function playeready_event(data, context) {
        if (data.userid == cc.beimi.user.id) {
            context.gamebtn.active = false;
        }
    },
    /**
     * 接收到服务端的 推送的 玩家数据，根据玩家数据 恢复牌局 , 玩家座位排列方式 ， 和麻将统一， 都是东南西北方式 排列
     * 0是首位玩家
     * 1是右侧玩家
     * 2是左侧玩家
     * 麻将还有一个对家
     * @param data
     * @param context
     */
    players_event: function players_event(data, context) {
        var inx = -1; //当前登录玩家的位置
        for (var i = 0; i < data.player.length; i++) {
            if (data.player[i].id == cc.beimi.user.id) {
                inx = i;break;
            }
        }
        if (data.player.length > 1 && inx >= 0) {
            var pos = inx + 1;
            while (true) {
                if (pos == data.player.length) {
                    pos = 0;
                }
                if (context.playerexist(data.player[pos], context) == false) {
                    context.newplayer(context.player.length, context, data.player[pos], context.player.length == 0 && !(pos == 0 && data.player.length < data.maxplayers));
                }
                if (pos == inx) {
                    break;
                }
                pos = pos + 1;
            }
        }
    },
    playerexist: function playerexist(player, context) {
        //检查玩家是否在房间
        var inroom = false;
        if (player.id == cc.beimi.user.id) {
            inroom = true;
        } else {
            for (var j = 0; j < context.player.length; j++) {
                console.log("检查当前玩家是否在房间，id:" + context.player[j].id);
                if (context.player[j].id == player.id) {
                    inroom = true;break;
                }
            }
        }
        return inroom;
    },
    /**
     * 接收到服务端的 推送的 玩家数据，根据玩家数据 恢复牌局
     * @param data
     * @param context
     */
    catch_event: function catch_event(data, context) {
        /**
         * 修改倍率
         */
        if (context.ratio) {
            context.ratio.string = data.ratio + "倍";
        }
        if (data.userid == cc.beimi.user.id) {
            //该我抢
            context.game.catchtimer(15);
        } else {
            //该别人抢
            for (var inx = 0; inx < context.player.length; inx++) {
                var render = context.player[inx].getComponent("PlayerRender");
                if (render.userid && render.userid == data.userid) {
                    render.catchtimer(15);
                    break;
                }
            }
        }
    },
    /**
     * 接收到服务端的 恢复牌局的数据 恢复牌局
     * @param data
     * @param context
     */
    recovery_event: function recovery_event(data, context) {
        var mycards = context.decode(data.player.cards);
        if (context.waittimer != null) {
            var timer = context.waittimer.getComponent("BeiMiTimer");
            if (timer) {
                timer.stop(context.waittimer);
            }
        }

        /**
         * 清理掉 extparam;
         * @type {boolean}
         */

        context.gamebtn.active = false;

        if (context.ratio) {
            context.ratio.string = data.ratio + "倍";
        }

        context.doLastCards(context.game, context, 3, 0);
        for (var inx = 0; inx < mycards.length; inx++) {
            var _pokencard = context.playcards(context.game, context, inx * 50 - 300, mycards[inx]);
            context.registerProxy(_pokencard);
        }
        /**
         * 赋值，解码牌面
         */
        for (var i = 0; i < context.pokercards.length; i++) {
            var pokencard = context.pokercards[i];
            pokencard.getComponent("BeiMiCard").order();
        }
        context.lastCardsPanel.active = true;

        if (data.lasthands) {
            var lasthands = context.decode(data.lasthands);
            /**
             * 底牌 ， 顶部的 三张底牌显示区域
             */
            for (var i = 0; i < context.lastcards.length; i++) {
                var last = context.lastcards[i].getComponent("BeiMiCard");
                last.setCard(lasthands[i]);
                last.order();
            }
            /**
             * 设置地主标志
             */
            if (data.banker.userid == cc.beimi.user.id) {
                context.game.lasthands(context, context.game, data.data);
            } else {
                context.getPlayer(data.banker.userid).setDizhuFlag(data.data);
            }
        }
        /**
         * 恢复最后出的牌
         */
        if (data.last != null) {
            var lastcards = context.decode(data.last.cards); //解析牌型
            if (data.last.userid == cc.beimi.user.id) {
                context.game.lasttakecards(context.game, context, data.last.cardsnum, lastcards, data.last);
            } else {
                context.getPlayer(data.last.userid).lasttakecards(context.game, context, data.last.cardsnum, lastcards, data.last);
            }

            if (data.nextplayer == cc.beimi.user.id) {
                context.game.playtimer(context.game, 25, data.automic);
            } else {
                context.getPlayer(data.nextplayer).playtimer(context.game, 25);
            }
        }
        if (data.cardsnum != null && data.cardsnum.length > 0) {
            for (var i = 0; i < data.cardsnum.length; i++) {
                context.getPlayer(data.cardsnum[i].userid).resetcards(data.cardsnum[i].cardsnum);
            }
        }
    },
    /**
     * 有玩家出炸
     * @param data
     * @param context
     */
    ratio_event: function ratio_event(data, context) {
        /**
         * 修改倍率
         */

        if (data.king == true) {
            //王炸，播放音效
        } else if (data.bomb == true) {
            //普通炸弹，播放音效
        }
        if (context.ratio) {
            context.ratio.string = data.ratio + "倍";
        }
    },
    /**
     * 接收到服务端的 推送的 玩家数据，根据玩家数据 恢复牌局
     * @param data
     * @param context
     */
    catchresult_event: function catchresult_event(data, context) {
        /**
         * 修改倍率
         */
        if (context.ratio) {
            context.ratio.string = data.ratio + "倍";
        }
        if (data.userid == cc.beimi.user.id) {
            //该我抢
            context.game.catchresult(data);
        } else {
            //该别人抢
            setTimeout(function () {
                context.getPlayer(data.userid).catchresult(data);
            }, 1500);
        }
    },
    /**
     * 接收到服务端的 推送的 玩家数据，根据玩家数据 恢复牌局
     * @param data
     * @param context
     */
    lasthands_event: function lasthands_event(data, context) {
        var lasthands = context.decode(data.lasthands);
        /**
         * 底牌 ， 顶部的 三张底牌显示区域
         */
        for (var i = 0; i < context.lastcards.length; i++) {
            var last = context.lastcards[i].getComponent("BeiMiCard");
            last.setCard(lasthands[i]);
            last.order();
        }
        /**
         * 当前玩家的 底牌处理
         */
        if (data.userid == cc.beimi.user.id) {
            context.game.lasthands(context, context.game, data);
            /**
             * 隐藏 其他玩家的 抢地主/不抢地主的 提示信息
             */
            for (var inx = 0; inx < context.player.length; inx++) {
                var render = context.player[inx].getComponent("PlayerRender");
                render.hideresult();
            }

            for (var i = 0; i < lasthands.length; i++) {
                var func = null;
                if (i == lasthands.length - 1) {
                    func = cc.callFunc(function (target, data) {
                        if (data.tempcontext) {
                            data.tempcontext.layout(data.tempcontext.poker, function (fir, sec) {
                                return fir.zIndex - sec.zIndex;
                            });
                        }
                    }, this, { tempcontext: context });
                }
                var _pc = context.current(context.game, context, 2 * 300 + (6 + i) * 50 - 300, lasthands[i], func);
                var beiMiCard = _pc.getComponent("BeiMiCard");
                beiMiCard.order();
                context.registerProxy(_pc);
            }

            context.game.playtimer(context.game, 25, true);
        } else {
            context.game.hideresult();
            for (var inx = 0; inx < context.player.length; inx++) {
                var render = context.player[inx].getComponent("PlayerRender");
                render.hideresult();
            }
            context.getPlayer(data.userid).lasthands(context, context.game, data);
            context.getPlayer(data.userid).playtimer(context.game, 25);
        }
        for (var inx = 0; inx < context.pokercards.length; inx++) {
            var pc = context.pokercards[inx];
            pc.zIndex = 54 - pc.card;
        }
    },
    /**
     * 接收到服务端的 推送的 玩家数据，根据玩家数据 恢复牌局
     * @param data
     * @param context
     */
    takecards_event: function takecards_event(data, context) {
        context.lasttip = null;
        if (data.allow == true) {
            var lastcards;
            if (data.donot == false) {
                lastcards = context.decode(data.cards); //解析牌型
            }
            if (data.userid == cc.beimi.user.id) {
                context.game.unselected(context, context.game);
                context.game.lasttakecards(context.game, context, data.cardsnum, lastcards, data);
            } else {
                context.getPlayer(data.userid).lasttakecards(context.game, context, data.cardsnum, lastcards, data);
            }

            context.game.selectedcards.splice(0, context.game.selectedcards.length); //清空
            if (data.over == false) {
                if (data.nextplayer == cc.beimi.user.id) {
                    context.game.playtimer(context.game, 25, data.automic);
                } else {
                    context.getPlayer(data.nextplayer).playtimer(context.game, 25);
                }
            }
        } else {
            //出牌不符合规则，需要进行提示
            context.game.notallow.active = true;
            setTimeout(function () {
                context.game.notallow.active = false;
            }, 2000);
            context.game.unselected(context, context.game);
        }
    },
    /**
     * 接收到服务端的 出牌提示信息
     * @param data
     * @param context
     */
    cardtips_event: function cardtips_event(data, context) {
        context.game.unselected(context, context.game);
        if (data.allow == true) {
            var tipcards = context.decode(data.cards); //解析牌型
            context.lasttip = tipcards.join(",");
            for (var inx = 0; inx < tipcards.length; inx++) {
                context.game.cardtips(context, tipcards[inx], tipcards);
            }
        } else {
            //出牌不符合规则，需要进行提示
            context.game.cardtipsfornot(context, context.game);
        }
    },
    /**
     * 接收到服务端的 推送的 玩家数据，根据玩家数据 恢复牌局
     * @param data
     * @param context
     */
    play_event: function play_event(data, context) {
        /**
         * 增加了全局变量，gamestatus , 用于控制当前玩家退出后恢复数据
         * @type {string}
         */
        cc.beimi.gamestatus = "playing";
        var mycards = context.decode(data.player.cards);
        if (context.waittimer) {
            var timer = context.waittimer.getComponent("BeiMiTimer");
            if (timer) {
                timer.stop(context.waittimer);
            }
        }

        var center = context.game.pokerpool.get();
        var left = context.game.pokerpool.get(),
            right = context.game.pokerpool.get();
        center.parent = context.root();
        left.parent = context.root();
        right.parent = context.root();
        center.setPosition(0, 200);
        left.setPosition(0, 200);
        right.setPosition(0, 200);

        var finished = cc.callFunc(function (target, data) {
            if (data.game) {
                data.game.pokerpool.put(data.current);
                data.game.pokerpool.put(data.left);
                data.game.pokerpool.put(data.right);

                /**
                 * 赋值，解码牌面
                 */
                for (var i = 0; i < data.self.pokercards.length; i++) {
                    var pokencard = data.self.pokercards[i];
                    pokencard.getComponent("BeiMiCard").order();
                }

                data.self.lastCardsPanel.active = true;
            }
        }, this, { game: context.game, self: context, left: left, right: right, current: center });

        context.doLastCards(context.game, context, 3, 0);

        /**
         *  发牌动作，每次6张，本人保留总计17张，其他人发完即回收
         */
        setTimeout(function () {
            context.dealing(context.game, 6, context, 0, left, right, mycards);
            setTimeout(function () {
                context.dealing(context.game, 6, context, 1, left, right, mycards);
                setTimeout(function () {
                    context.dealing(context.game, 5, context, 2, left, right, mycards, finished);
                    context.reordering(context);
                }, 500);
            }, 500);
        }, 0);
    },
    /**
     * 打完牌，进入结算界面，结算界面流程：
     * 1、提示你赢/输了
     * 2、1秒后所有玩家的牌翻出来，显示剩余的牌
     * 3、2秒后显示结算界面
     * 4、玩家点选明牌开始还是继续游戏
     * @param data
     * @param context
     */
    allcards_event: function allcards_event(data, context) {
        /**
         * 全局变量控制，用于恢复数据
         * @type {string}
         */
        cc.beimi.gamestatus = "notready";
        //结算界面，
        var player = void 0;
        for (var i = 0; i < data.players.length; i++) {
            var temp = data.players[i];
            if (temp.userid != cc.beimi.user.id) {
                var cards = context.decode(temp.cards); //解析牌型
                var tempscript = context.getPlayer(temp.userid);
                for (var inx = 0; inx < cards.length; inx++) {
                    //tempscript.lasttakecards(context.game, context, cards.length, cards, data);
                    /**
                     * 最后牌局结束以后，显示所有玩家的手牌
                     */
                }
            } else {
                player = temp;
            }
        }
        if (player != null) {
            /**
             * 更新个人账号资产信息
             */
            context.pva("gold", player.balance);
            /**
             * 刷新个人资产显示 , 可以增加相关动画显示，duang的一声，显示的金币变成金光闪闪的，然后再变回去
             */
            context.updatepva();
        }
        setTimeout(function () {
            if (player != null) {
                if (player.win == true) {
                    context.summarypage = cc.instantiate(context.summary_win);
                } else {
                    context.summarypage = cc.instantiate(context.summary);
                }
                context.summarypage.parent = context.root();
                var _temp = context.summarypage.getComponent("SummaryDetail");
                _temp.create(context, data);
            }
            /**
             * 隐藏顶部的 底牌 显示区域
             * @type {boolean}
             */
            context.lastCardsPanel.active = false;

            if (data.gameRoomOver == true) {
                //房间解散
                for (var inx = 0; inx < context.player.length; inx++) {
                    context.player[inx].destroy();
                }
                context.player.splice(0, context.player.length); //房间解散，释放资源
                context.player = new Array();
                context.clean();
            }
        }, 2000);
    },
    getPlayer: function getPlayer(userid) {
        var tempRender;
        for (var inx = 0; inx < this.player.length; inx++) {
            var render = this.player[inx].getComponent("PlayerRender");
            if (render.userid && render.userid == userid) {
                tempRender = render;break;
            }
        }
        return tempRender;
    },
    dealing: function dealing(game, num, self, times, left, right, cards, finished) {
        /**
         * 处理当前玩家的 牌， 发牌 ，  17张牌， 分三次动作处理完成
         */
        for (var i = 0; i < num; i++) {
            var myCards = self.current(game, self, times * 300 + i * 50 - 300, cards[times * 6 + i], finished);
            this.registerProxy(myCards);
        }
        self.otherplayer(left, 0, num, game, self);
        self.otherplayer(right, 1, num, game, self);
    },
    otherplayer: function otherplayer(currpoker, inx, num, game, self) {
        if (inx == 0) {
            var seq = cc.sequence(cc.spawn(cc.moveTo(0.2, -350, 50), cc.scaleTo(0.2, 0.3, 0.3)), cc.moveTo(0, 0, 200), cc.scaleTo(0, 1, 1));
            currpoker.runAction(seq);
        } else {
            var _seq = cc.sequence(cc.spawn(cc.moveTo(0.2, 350, 50), cc.scaleTo(0.2, 0.3, 0.3)), cc.moveTo(0, 0, 200), cc.scaleTo(0, 1, 1));
            currpoker.runAction(_seq);
        }
        //currpoker.setScale(1);
        var render = self.player[inx].getComponent("PlayerRender");
        for (var i = 0; i < num; i++) {
            render.countcards(1);
        }
    },
    doLastCards: function doLastCards(game, self, num, card) {
        //发三张底牌
        for (var i = 0; i < num; i++) {
            var width = i * 80 - 80;
            var currpoker = game.minpokerpool.get();
            currpoker.getComponent("BeiMiCard").setCard(card);
            currpoker.card = card;
            currpoker.parent = this.lastCardsPanel;
            currpoker.setPosition(width, 0);

            self.lastcards[self.lastcards.length] = currpoker;
        }
    },
    registerProxy: function registerProxy(myCard) {
        if (myCard) {
            var beiMiCard = myCard.getComponent("BeiMiCard");
            beiMiCard.proxy(this.game);
        }
    },
    playcards: function playcards(game, self, posx, card) {
        return self.current(game, self, posx, card, null);
    },
    current: function current(game, self, posx, card, func) {
        var currpoker = game.pokerpool.get();
        var beiMiCard = currpoker.getComponent("BeiMiCard");
        beiMiCard.setCard(card);
        currpoker.card = card;
        currpoker.parent = self.poker;
        currpoker.setPosition(0, 200);

        currpoker.setScale(1, 1);
        currpoker.zIndex = 100 - card;

        self.pokercards.push(currpoker);

        if (func != null) {
            var seq = cc.sequence(cc.moveTo(0.2, posx, -180), func);
            currpoker.runAction(seq);
        } else {
            var action = cc.moveTo(0.2, posx, -180);
            currpoker.runAction(action);
        }
        return currpoker;
    },
    reordering: function reordering(self) {
        for (var i = 0; i < self.pokercards.length; i++) {
            self.pokercards[i].parent = self.poker;
        }
    },
    newplayer: function newplayer(inx, self, data, isRight) {
        //添加新玩家，绘制
        var pos = cc.v2(520, 100);
        if (isRight == false) {
            //是否在右边，三个人斗地主，其他两个人不是在左就是在右边
            pos = cc.v2(-520, 100);
        }
        var game = self.getCommon("DizhuDataBind");
        if (game && game.playerspool.size() > 0) {
            self.player[inx] = game.playerspool.get();
            self.player[inx].parent = self.root();
            self.player[inx].setPosition(pos);
            self.player[inx].userId = data.id;
            var render = self.player[inx].getComponent("PlayerRender");
            render.initplayer(data, isRight);
        }
    },
    playerLeave_event: function playerLeave_event(data, context) {
        // context.player[1].destroy;
        var game = context.getCommon("DizhuDataBind");
        var pos = -1;
        for (var inx = 0; inx < context.player.length; inx++) {
            if (context.player[inx].userId == data.player.id) {
                pos = inx;
                game.playerspool.put(context.player[inx]);
            }
        }

        if (context.isInviteDestroy == true) {
            context.invite = cc.instantiate(context.inviteplayer);
            var script = context.invite.getComponent("BeiMiQR");
            script.init(data.roomid);
            context.invite.parent = context.root();
        }

        console.log(context.invite);

        context.player.splice(pos, 1);
        console.log("玩家离开啦！！！");
    },
    roomMsg_event: function roomMsg_event(data, context) {
        console.log("收到玩家发送的房间信息：" + data.roomMsg);
        if (cc.beimi.user.id != data.player.id) {
            context.chat.getComponent("chat").showMsg(data);
        }
    },


    // called every frame, uncomment this function to activate update callback
    // update: function (dt) {

    // },
    /**
     * 不抢/叫地主
     */
    givup: function givup() {
        if (this.ready()) {
            var socket = this.socket();
            socket.emit("giveup", "giveup");
        }
    },
    /**
     * 开始游戏
     */
    startgame: function startgame(opendeal) {
        if (this.ready()) {
            var socket = this.socket();
            socket.emit("start", opendeal);
        }
    },
    /**
     * 不抢/叫地主
     */
    cardtips: function cardtips() {
        if (this.ready()) {
            var socket = this.socket();

            if (this.lasttip != null) {
                socket.emit("cardtips", this.lasttip);
            } else {
                socket.emit("cardtips", "");
            }
            this.lasttip = null;
        }
    },
    /**
     * 抢/叫地主触发事件
     */
    docatch: function docatch() {
        if (this.ready()) {
            var socket = this.socket();
            socket.emit("docatch", "docatch");
        }
    },
    /**
     * 出牌
     */
    doPlayCards: function doPlayCards() {
        if (this.ready()) {
            var socket = this.socket();
            this.game.selectedcards.splice(0, this.game.selectedcards.length);
            for (var i = 0; i < this.pokercards.length; i++) {
                var card = this.pokercards[i];
                var temp = card.getComponent("BeiMiCard");
                if (temp.selected == true) {
                    this.game.selectedcards.push(temp.card);
                }
            }
            socket.emit("doplaycards", this.game.selectedcards.join());
        }
        this.lasttip = null;
    },
    /**
     * 不出牌
     */
    noCards: function noCards() {
        if (this.ready()) {
            var socket = this.socket();
            socket.emit("nocards", "nocards");
        }
        this.lasttip = null;
    },
    clean: function clean() {
        for (var inx = 0; inx < this.pokercards.length; inx++) {
            var pc = this.pokercards[inx];
            this.game.pokerpool.put(pc); //回收回去
        }
        this.pokercards.splice(0, this.pokercards.length);
        for (var i = 0; i < this.lastcards.length; i++) {
            this.game.minpokerpool.put(this.lastcards[i]);
        }

        this.lastcards.splice(0, this.lastcards.length);

        for (var i = 0; i < this.player.length; i++) {
            var player = this.player[i].getComponent("PlayerRender");
            player.clean(this.game);
        }
        this.player.splice(0, this.player.length);

        this.game.clean(this);
        this.ratio.string = "15倍";
    },
    onCloseClick: function onCloseClick() {
        this.continuegamebtn.active = true;
    },
    restart: function restart(command) {
        this.game.restart();
        this.statictimer("正在匹配玩家", 5);
        /**
         * 系统资源回收完毕，发送一个 重新开启游戏的 通知
         */
        if (this.ready()) {
            var socket = this.socket();
            socket.emit("restart", command);
        }
    },
    continuegame: function continuegame() {
        this.continuegamebtn.active = false;
        this.restart("begin");
    },
    statictimer: function statictimer(message, time) {
        this.waittimer = cc.instantiate(this.waitting);
        this.waittimer.parent = this.root();

        var timer = this.waittimer.getComponent("BeiMiTimer");
        if (timer) {
            timer.init(message, time, this.waittimer);
        }
    },
    onDestroy: function onDestroy() {
        this.inited = false;
        this.cleanmap();
        if (this.ready()) {
            var socket = this.socket();
            socket.emit("leave", "leave");
        }
    }
});

cc._RF.pop();
        }
        if (CC_EDITOR) {
            __define(__module.exports, __require, __module);
        }
        else {
            cc.registerModuleFunc(__filename, function () {
                __define(__module.exports, __require, __module);
            });
        }
        })();
        //# sourceMappingURL=DizhuBegin.js.map
        